Process for the vector quantization of low bit rate vocoders

ABSTRACT

A process for the vector quantization of low bit rate vocoders, including determining a coding region by surrounding with an envelope a scatter of points of an autocorrelation matrix of reflection coefficients of a filter configured to model a vocal tract, wherein the envelope has a shape selected from the group consisting of a hyperellipsoid shape and a pyramidal shape, the envelope being centered at the barycenter of the scatter of points; determining principal axes of the volume of points inside the envelope; projecting area coefficients of the autocorrelation matrix onto the principal axes; partitioning the interior volume of the envelope into elementary volumes; and coding partition coefficients resulting from partitioning the interior volume on the basis of coordinates of said partition coefficients in a space defined by the principal axes of the volume of the points inside the envelope, while allocating as code values only values corresponding to locations of the elementary volumes in which said partition coefficients lie.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates to a process for the vector quantizationof low bit rate vocoders.

It applies in particular to linear-prediction vocoders similar to thosedescribed for example in the THOMSON-CSF Technical Journal, Volume 14.No. 3, Sep. 1982, pages 715 to 731, and according to which the speechsignal is identified at the output of a digital filter whose inputreceives, either a periodic waveform corresponding to those of thevoiced sounds, viz. vowels, or to a random waveform corresponding tothose of the unvoiced sounds, viz. the majority of consonants.

2. Discussion of the Background

It is known that the auditory quality of linear-prediction vocodersdepends in large part on the accuracy with which their predictive filteris quantized and that this quality generally decreases as the digitalbit rate between vocoders decreases since the accuracy of quantizationof the filter then becomes insufficient. Numerous quantization processesof the type of those described for example in Patent Application EP0504485 A2 or in U.S. Pat. No. 4,907,276 have been developed in order tosolve this problem. In general, the speech signal is segmented intoindependent frames of constant duration and the filter is renewed ateach frame. Thus, to arrive at a bit rate of around 1820 bits persecond, the filter must, according to a standard implementation, berepresented by a packet of 41 bits transmitted every 22.5 milliseconds.For non-standard links with a lower bit rate, of the order of 800 bitsper second, fewer than 800 bits per second have to be transmitted inorder to represent the filter, this constituting a bit rate ratio ofapproximately 3 as compared with standard implementations. 30 bits onaverage are used to quantize one filter out of two, and these 30 bitsare composed of 3 bits defining a quantization scheme and 27 bits forquantizing 10 quantities obtained from LAR (Log Area Ratio) coefficientsby displacement and rotation in the 10-dimensional space thus defined.As a result the quantization now begins to be only approximatelytransparent, and auditory compensation of this artefact is necessary, bycoarse quantization of the filters located in the transitions of thespeech signal and fine quantization of those corresponding to stablezones. To obtain sufficient accuracy of quantization of the predictivefilter despite everything, the conventional approach consists inemploying a vector quantization scheme which is intrinsically moreefficient than that used in standard systems where the 41 bits employedserve for the scalar quantization of the P=10 coefficients of theirprediction filter. The method relies on using a dictionary containing aspecified number of standard filters obtained by learning. It consistsin transmitting only the page or the index at which the standard filterrate which is obtained, only 10 to 15 bits per filter being transmittedinstead of the 41 bits required in scalar quantization mode, howeverthis bit rate reduction is obtained at the cost of a very large increasein the memory size required to store the elements of the dictionary andof a considerable computational burden attributable to the complexity ofthe filter search algorithm.

By applying this approach also to low bit rate vocoders of 800 bits/sand less, it is commonly supposed that 24 bits are sufficient for acomposite dictionary produced from two dictionaries with 4,096 elementsaccounting for the first four and last six LSPs respectively. The majordrawback of this type of quantization again resides in the need tocompile this dictionary, to store it and to perform the quantizationproper.

Alternatives to the vector quantization scheme have also been proposedin order to reduce the number of elements stored in the dictionary.Thus, a technique of pyramidal vector quantization is in particularknown, a description of which may be found in the journal IEEE trans. onINFTH Vol. IT 32 No. 4, July 1986, pages 568 to 582 by Thomas R. Fischerentitled "A pyramid vector quantizer". According to this technique themultidimensional input data are distributed over the vertices of aregular grid included within a pyramid of multiple dimension. Thisquantization technique is applied mainly in respect of data with aLaplacian distribution characteristic. However, the reduction in bitrate which results from this is not always sufficiently appreciable.This is due in particular to the fact that in practice the overall shapeof the multidimensional data to be processed is in actual fact inscribedwithin an ellipsoid, especially when using a prediction/extrapolationcomputation system which always involves a Gaussian characteristic shapeof data. Moreover, the pyramid which is inscribed on this ellipsoidleads to the coding of the points which lie outside the ellipsoidsurrounding the scatter of points to be coded, thereby making itnecessary to dimension code words with a number of bits which exceedswhat is strictly necessary.

SUMMARY OF THE INVENTION

The objective of the invention is to overcome the aforementioneddrawbacks.

To this end, the subject of the invention is a process for the vectorquantization of low bit rate vocoders, characterized in that it consistsin determining the coding region by surrounding with an envelope thescatter of the points of the auto-correlation matrix of the reflectioncoefficients of the filter for modelling the vocal tract, in determiningthe principal axes of the volume of points inside the envelope, inprojecting the coefficients of the autocorrelation matrix onto theprincipal axes, in partitioning the interior volume of the envelope intoelementary volumes and in coding the coefficients resulting from theprojection on the basis of their coordinates in the space defined by theprincipal axes of the volume of the points inside the envelope, whileallocating as code values only those values corresponding to thelocations of the elementary volumes in which they lie.

The main advantage of the invention is that it employs a predictionfilter quantization process which requires virtually no more binaryelements to quantize the points representing the prediction filters thana dictionary-based vector quantization process, whilst remaining simpleand fast to implement and occupying only a small memory space.

BRIEF DESCRIPTION OF THE DRAWINGS

Other characteristics and advantages of the invention will emerge belowwith the aid of the description which follows with regard to the figuresof the appended drawings which represent:

FIG. 1 a flow chart illustrating the speech coding process employed bythe invention.

FIG. 2 a two-dimensional vector space depicting a distribution of areacoefficients derived from the reflection coefficients modelling thevocal tract.

FIG. 3 an illustration of the coding process according to the inventionin a three-dimensional space.

FIGS. 4 to 8b, example distributions of the coding of points in athree-dimensional space obtained by implementing the process accordingto the invention.

DISCUSSION OF THE PREFERRED EMBODIMENTS

The coding process according to the invention consists, after havingpartitioned the speech signal into frames of constant length of around20 to 25 ms, as is customarily the case in vocoders, in determining andcoding the characteristics of the speech signal on successive frames bydetermining the energy of the signal P times per frame.

The synthesis of the speech signal on each frame is then carried out bydeframing and decoding the values of the coded characteristics of thespeech signal.

The representative steps of the coding process according to theinvention which are represented in FIG. 1 consist in computing in step1, after a step (not represented) of sampling the speech signal S_(K) oneach frame and quantizing the samples over a specified number of bitsfollowed by a pre-emphasizing of these samples, the coefficients K_(i)of a filter for modelling the vocal tract on the basis ofautocorrelation coefficients R_(i) of the samples S_(K) according to arelation of the form ##EQU1##

The coefficients K_(i) are computed for example by applying the knownalgorithm by M. Leroux-Guegen, a description of which can be found inthe article from the journal IEEE Transaction on Acoustics Speech, andSignal Processing, June 1977 entitled "A fixed point computation ofpartial correlation coefficients". This computation amounts to invertinga square matrix whose elements are the coefficients R_(i) of relation(1).

The next step 2 consists in non-linearly distorting the reflectioncoefficients by transforming them into area coefficients denoted LAR_(i)from the abbreviation LOG AREA RATIO using the relation ##EQU2## so asin step 3 to compute the eigenvectors of an autocorrelation matrix ofthe coefficients LAR_(i) which define in the P-dimensional space thefavoured directions of a scatter of points whose coordinates are thecoefficients LAR_(i) with i=1-P. By way of example the scatter of pointsrepresented in FIG. 2 in a space with just two dimensions exhibits twofavoured directions symbolized by the eigenvectors V₁ and V₂.

Returning to FIG. 1, step 4 consists in projecting the LAR coefficientsonto the favoured directions by computing for example coefficientsλ_(i), representing the sum of the projections of the coefficients(LAR_(j) LARj) onto the eigenvectors V_(i) to V_(p) of theautocorrelation matrix of the coefficients LAR, using the relation##EQU3## in which V_(i),j denotes the eigenvectors and LAR_(j) is themean value of each coefficient LAR_(j) of rank j.

Since each of the coefficients λ_(i) moves between a minimum value-λ_(imax) and a maximum value +λ_(imax), this movement makes it possibleto approximate the shape of the observed scatter of points by ahyperellipsoid, the values of the semi-major axes of which arerepresented by the coefficients λ_(imax).

For each of the λ_(i), a uniform quantization is then performed betweena minimum value λ_(imini) and a maximum value λ_(imax) using a number ofbits n_(i) which is computed by the conventional means on the basis ofthe total number N of bits used to quantize the filter and thepercentages of inertia corresponding to the eigenvectors V_(i).

The coefficients λ_(i) are quantized using a measure of distance betweenfilters, the most natural of which is the weighted Euclidean distance ofthe form: ##EQU4## in which the coefficients γ_(i) are a decreasingfunction of their rank i and are fitted experimentally.

In an equivalent manner, given that the coefficients γ_(i) are centredabout the barycentre of the hyperellipsoid, the same result can also beachieved by using a purely Euclidean distance measure pertaining to themodified coefficients, such as ##EQU5## The representative points of thefilters with coordinates μ_(i) then lie inside a hyperellipsoid ofdimension P, the P semi-major axes of which are respectively equal toμ_(imax) with μ_(imax) =λ_(imax) γ_(i) ^(1/2).

Under these conditions if each of the coordinates μ_(i) were quantizeduniformly between -μ_(imax) and +μ_(imax), the number of bits requiredwould then be equal to the logarithm to the base 2 of the ratio betweenthe quantizable parallelepipedal volume (slab) and the volume of anelementary hypercube according to the relation ##EQU6## where Δ is thequantization interval. However, this definition leads to therepresentation not only of the points inside the ellipsoid but also amultitude of exterior points. For example, in dimension 3, this leads tothe representation of twice as many points as necessary. This expansionin the number of points to be coded grows as the number of dimensions ofthe space to be considered increases.

Thus considering the volume of an ellipsoid defined for P even by therelation ##EQU7## the number of bits N_(E) strictly necessary is thengiven by ##EQU8## thus giving ##EQU9##

In the case of a prediction filter with P=10 coefficients thisrepresents a difference of -8.65 bits and shows that in principle it issufficient to use only 24 bits for N_(E) instead of the 33 bits requiredto quantize the coefficients μ_(i) independently.

Under these conditions it appears that the only means of actually makinga saving in the bits desired consists in forming a quantization in aspace which is strictly limited inside the useful volume, of theellipsoid of the points μ_(i). The invention achieves this by executing,in step 5, an algorithm which makes it possible unambiguously toenumerate all the points lying inside this volume.

For the convenience of the account, it will be assumed in what followsthat the volume of the points is delimited by an envelope of ellipsoidalor pyramidal shape, but it will be appreciated that the coding processof the invention which is described also holds true for volumes of anyenvelope.

Assuming for simplicity that the space of the data to be quantized is aspace of dimension 3 (N=3) and that all the points inside an ellipsoidwith orthonormal axes 2X, 2Y, 2Z can be quantized using a quantizationinterval equal to one, the quantization process according to theinvention applied to this space consists in associating a unique numberwith each set of integer coordinates x0, y0, z0 satisfying the relation:##EQU10##

As FIG. 3 shows, this association is carried out in three steps. A firststep consists in traversing the x axis and in computing the total numberof points lying in the slices of the ellipsoid which are perpendicularthereto and which cut the x axis at points for which x takes thesuccessive integer values -X, -X+1, . . . , x-2, x-1. The second stepconsists in traversing the y axis while adding to the previous resultthe sum of the numbers of points lying in the slices of the ellipsoidwhose abscissa is equal to x and whose ordinate is equal in successionto -Y(x), -Y(x+1), . . . , y-2, y-1 where Y(x)≦Y and is the largestvalue for which the point with coordinates (x Y(x), 0) lies in theellipsoid or its surface. Finally, according to the third step, the zaxis is traversed while adding to the previous result the sum of thenumbers of points lying in the slices whose abscissa is equal to x,whose ordinate is equal to y and whose altitude is equal successively to-Z(x,y), -Z(x,y)+1, . . . , z-2, z-1 where Z(x,y)≦Z and is the largestvalue for which the point with coordinates (x,y,Z(x,y) lies in theellipsoid or its surface. The final result gives the exact number ofpoints extending ahead of the point to be quantized, that is to say thepoints for which x or y or z is less than xo, yo or zo respectively.This principle can naturally be extended to spatial dimensions of anyorder. For a space of order N, the various volumes of dimensions 2, 3, .. . , N-1 are precomputed and stored in a read-only memory. Bygeneralizing this principle to an ellipsoid with N dimensions, anddenoting the dimensions of the semi-axes as A₁, A₂, . . . , A_(N), thevolume inside the ellipsoid is defined by the relation:

    V.sub.n=∫.sub.-A.sbsb.N.sup.A.sbsp.N dx.sub.N ∫.sub.-α.sbsb.N-1.sup.+α.sbsp.N-1 ∫.sub.A.sbsb.N-1.sup.A.sbsp.N-1 dX.sub.N-1 . . . ∫.sub.-α.sbsb.1.sub.A.sbsb.1.sup.+α.sbsp.1.sup.A.sbsp.1 dX.sub.1                                                  (11)

with α_(m) = ##EQU11## and the equation of its surface is defined by therelation: ##EQU12## Denoting by V_(m)(A) the volume of a slice with mdimensions (m<or equal to N) of the ellipsoid, in which the m^(th)coordinate lies between -A and +A, the latter is expressed by therelation: ##EQU13## Using the relation (14) it is easy to deduce arecurrence relation linking two volumes with consecutive dimensions,i.e.: ##EQU14## The number of points to be quantized can then beobtained from the above relations by considering for example that thequantization interval is equal to 1 and that the dimensions of the axesAi are positive integers. This determination can be achieved byconsidering in succession the isolated points (dimension 0), the seriesof contiguous points (dimension 1), and then by iteratively computingthe volumes of dimensions 2 . . . N-1.

A microprogram enabling this result to be obtained is given in Appendix1.

The quantization algorithm according to the invention is deduced fromthe abovementioned example in 3 dimensions. This algorithm consists inaccumulating in the code value the number of points encountered onstarting from a minimum value of the coordinates so as to arrive at thecode value of the point considered. To perform this processingoperation, the actual values of the coordinates X_(i) are firstlyconverted into their nearest integer value. The resulting values arethen corrected so as to be certain that the corresponding point doesindeed lie inside the ellipsoid, since for any points which may beoutside, it is supposed that the quantization error may be larger thanthat obtained for the points inside. An optimum procedure for processingthese points would be to find the points which seem to be nearest to theinterior of the ellipse. However, with the exception of a quantizing ofpoints inside a sphere, there is unfortunately no simple process forperforming this processing operation. A suboptimum algorithm for placingthese points iteratively inside the ellipsoid by modifying theirsuccessive coordinates is as follows:

R=A_(N)

FOR n=N DOWN TO 1

IF X_(n) >R THEN X_(n) =R

ELSE IF X_(n) <-R THEN X_(n) =-R

R=(A_(n-1) /A_(n)) (R² -X_(n) ²)1/2

END FOR

In practice the instructions of the above algorithm have to beincorporated into the microprogram for the coding proper by using thevolumes V_(n) (A) already computed. This algorithm involvesaccumulating, in the final code, the number of points left behind thecoded point with coordinates (X₁ . . . X_(N)) when starting from a pointwith coordinates (0, 0 . . . 0, A_(N)) on the surface of the ellipse anddescending toward the point to be quantized. A microprogram forexecuting this coding algorithm is given in Appendix 2.

Naturally the maximum execution time for the above algorithm can beshortened by virtue of the symmetries. Thus, if Code0 represents thecode of the origin point with coordinates (00 . . . 0) and C representsthe code value for the point with coordinates X₁, . . . , X_(N) the codecorresponding to the symmetric point (-X₁, . . . , -X_(N)) is exactlyequal to 2* Code0-C. To take this into account, the above microprogramcan be supplemented with the following instructions:

Inversion=FALSE

IF X_(N) >=0

Inversion=TRUE

FORi=1 TO N DO X_(i) =-X_(i)

END IF

IF Inversion THEN Code 2 Code0-Code

An example quantization is represented in FIG. 4 for the axis values A₁=1, A₁ =3 and A₁ =4. In this representation there are in total 37centroids of elementary cubes and the barycentre of the ellipsoidcorresponds to the code 18. For comparison, an example of an equivalentpyramid quantization is represented in FIG. 5. In this case thebarycentre corresponds to the code 14.

The dequantization algorithm proceeds by seeking to reconstruct theterms which were added to give the value of the code, knowing that thisreconstruction is by nature unique.

A corresponding microprogram is given in Appendix 3.

In order to account for certain situations in which it may be ofinterest to displace the origin of the set of centroids, the abovealgorithms may again be modified by considering half-integer rather thaninteger coordinates. A first possibility can consist in making aquantizer whose axes are twice the dimension of the axes A, required. Avector of N actual values can then be quantized after doubling, usingodd integers only. The above algorithm can then be used, the output codeobtained being converted by a table giving the final code. Thistranscoding is necessary for the reason that although only around aquarter of the original centroids need to be considered, this reductiondoes not correspondingly ease the execution of the algorithm. This isbecause, as FIG. 6 shows, with axis dimensions A₁ =1, A₂ =3, A₃ =4, anextended ellipsoid of dimensions 2, 6 and 8 is then obtained whichcontains 369 centroids, this being very substantial compared with the 56centroids of the ellipsoid devised with half-integer coordinates.

A second possibility can consist in modifying the initialization of thealgorithm, the coding and the decoding in such a way as to use evencoordinates only. Corresponding modified microprograms are given inAppendix 4.

The codes are transmitted as binary words. However, since a priori thereis no particular reason why the number of points lying inside anellipsoid should form an exact power of two, it appears highly desirablein order to use an optimal number of bits in the formation of the code,that this number be as close as possible to an exact power of two. Thiscan be obtained by adjusting the volume of the ellipsoid by fractionalrather than integer axis lengths.

In order to simplify the account, it will be assumed that the fractionsrepresenting the axes A, have a common denominator. In practice, thedenominator values 1, 2, 3 are sufficient to obtain without difficultyellipsoids containing a number of centroids as near as possible to anexact power of two.

For example, by considering in dimension 4 an ellipsoid of dimensions(3, 4, 5, 6), the latter contains exactly 1765 points. This number liesexactly between 1024 and 2048. By modifying these dimensions in theratios (9/3, 13/3, 15/3, 19/3) this number is changed by the number 2025which is 98.87% close to 2048 and may be said to represent an equivalentbinary loss of log.2(0.9887)=0.016 bits. The difference 2048-2025=23codes lost can then be used for coding particular configurations ifnecessary.

Consequently, the above algorithms may again be modified by consideringaxis lengths of the form (A₁ /D, A₂ /D, . . . , A_(N) /D) where D is acommon denominator of small value. High values of D are not necessarysince in practice, it is always possible to obtain good coding with D=1,2 or 3.

The introduction of a common denominator leads to the followingprocessing operations being performed:

1--definition of the axes:

    a.sub.i =A.sub.i /D i=1 . . . N                            (16)

2--equation of the ellipsoid (K=2) of the pyramid (K=1): ##EQU15##3--maximum value of X_(n) ##EQU16## 4--By reducing to the samedenominator and keeping only the numerators, the following recurrenceformulae are defined: ##EQU17##

The above relations show that if D is different from 1 or if the axesA_(i) do not have small dimensions or if the dimensions N are large, alarge number of points must be computed and that this computation mustbe performed in multiprecision arithmetic. The maximum value of X_(n) isexactly (Num_(n) /Den_(n))^(1/2), and this value is almost never aninteger, and therefore it is impossible to use the arrays such as V_(n)(X_(n)) when programming. In practice, this problem can be solved byusing two arrays, one array for the volumes and one array of valuescorresponding to the numerator since the denominators do not change. Inthis way, access to a specified volume may be achieved through thenumerator corresponding to that sought. To reduce the computation timethe numerators are stored in ascending order together with theircorresponding volume. The initialization, coding and decodingmicroprograms are then modified in the manner represented in Appendix 5.

Another possibility consists in considering only the centroids for whichthe sum of the coordinates is even or odd. This amounts to keeping onlyhalf the original centroids, the latter being distributed over theoriginal grid with origin DN here denoted D_(n0) where its complementD_(n1) which does not include the origin.

The main advantage of proceeding in this way is that it makes itpossible to decrease the average quantization error by -0.25 db if N=3where by around -0.4 db for N=4 to 10. This leads to modifying theinitial quantization algorithm by considering only the points with evenor odd coordinates respectively. Under these conditions the quantizationalgorithm consists in quantizing the points as before by searching forthe nearest integer values of each coordinate and in modifying theinteger coordinates which are most distant from their actual originalvalue. However, the coding and decoding are then slightly more complexthan for a grid of points having integer coordinates.

This is because two sets of volumes have to be found for dimensions 1 toN-1, a first set V₀,n(A) of n-dimensional volumes having an odd sum ofcoordinates to a second set V_(1n) (A) of volumes of dimension n havingan even sum of coordinates. Under these conditions the computation ofthe volumes takes place in the manner described by the microprogram ofAppendix 6.

An example of ellipsoidal vector quantization for D₃,0 and D₃,1 isrepresented in FIGS. 7a and 7b. In this representation, the three axeshave dimensions 2, 4, 5 respectively, that is to say they are slightlylarger than those of the earlier examples in order to obtain asufficient number of points. Each centroid is joined to its nearestneighbours in the same way as in FIGS. 4 and 6. It can be verified inthese figures that the barycentre belongs (FIG. 7a) or does not belong(FIG. 7b) to the set of centroids.

A generalization of the process to a pyramid quantization is alsorepresented in FIGS. 8a and 8b.

    __________________________________________________________________________    APPENDICES                                                                    __________________________________________________________________________    Appendix 1                                                                      1. For the isolated points                                                      V.sub.o (0)=1                                                             2. For the series of contiguous points of dimension 1                             FOR A + 0 TO A.sub.1 D0 V.sub.1 (A) = 2*A+1                               3. For the volumes with dimensions 2, . . . , N-1                               FOR n = 2 TO N-1                                                                FOR A = 0 TO A.sub.n XX                                                         V.sub.n (A) = 0                                                           FOR X.sub.n = 0 TO A                                                                X.sub.n-1 = (A.sub.n-1 /A.sub.n) (A.sup.2 - X.sub.n.sup.2).sup.1/2            IF X.sub.n = 0                                                                      THEN V.sub.n (A) = V.sub.n-1 (X.sub.n-1)                           ELSE V.sub.n (A) = V.sub.n (A) + 2*V.sub.n-1 (X.sub.n-1)                   END FOR                                                                           END FOR                                                                   END FOR                                                                         Appendix 2                                                                    Code = 0                                                                      R = A.sub.N                                                                   FOR n = N DOWN TO 1                                                             IF X.sub.n > -R                                                                 FOR X = -R TO X.sub.n-1                                                         Y = INT ((A.sub.n-1 /A.sub.n)(R.sup.2 - X.sup.2).sup.1/2)                      Code = Code + V.sub.n-1 (Y)                                          END FOR                                                                           END IF                                                                      R = (A.sub.n-1 /A.sub.n) (R.sup.2 - X.sub.n.sup.2).sup.1/2                  END FOR                                                                         Appendix 3                                                                    R = A.sub.N                                                                   FOR n = N DOWN TO 1                                                             X.sub.n = -R                                                                Y = INT ((A.sub.n-1 /A.sub.n)(R.sup.2 - X.sub.n.sup.2).sup.1/2)                  WHILE Code >=V.sub.n-1 (Y)                                               Code = Code - V.sub.n-1 (Y)                                                     X.sub.n = X.sub.n + 1                                                         Y = INT ((A.sub.n-1 /A.sub.n)(R.sup.2 - X.sub.n.sup.2).sup.1/2)              END WHILE                                                                     R = Y                                                                        END FOR                                                                          An improvement to the speed of execution of this microprogram can           also be obtained by introducing the following instructions:                   Inversion = FALSE                                                             IF Code>Code 0                                                                   Inversion = TRUE                                                               Code = 2 Code 0 - Code                                                   END IF                                                                          (decoding giving X.sub.i)                                                     IF Inversion THEN FOR i = 1 TO N DO X.sub.i = -X.sub.i                        Appendix 4                                                                    FOR A = 0 TO A.sub.1 DO V.sub.1 (A) = 2 INT((A+1)/2)                          FOR n = 2 TO N-1                                                                FOR A = 0 TO A.sub.n                                                            V.sub.n (A) = 0                                                           FOR X.sub.n = 0 TO INT((A - 1)/2)                                                   X.sub.n = 2 X.sub.n + 1                                                 X.sub.n-1 = INT(((A.sub.n-1 /A.sub.n)(A.sup.2 - X.sub.n.sup.2).sup.1/2              -1)/2)                                                                  X.sub.n-1 = 2 X.sub.n-1 + 1                                                   V.sub.n (A) = V.sub.n (A) + 2 V.sub.n-1 (X.sub.n-1)                         END FOR                                                                           END FOR                                                                   END FOR                                                                         Modification of the coding                                                    Code = 0                                                                      R = A.sub.N                                                                   FOR n = N DOWN TO 1                                                             X.sub.n = INT((X.sub.n - 1)/2);                                             r = INT((R - 1)/2)                                                            IF X.sub.n >-r                                                                    FOR x = -r TO X.sub.n-1                                                         X = 2 x + 1                                                             y = INT(((A.sub.n-1 /A.sub.n)(R.sup.2 -X.sup.2).sup.1/2 -1)/2)                Y = 2 y + 1                                                                   Code = Code + V.sub.n-1 (Y)                                                 END FOR                                                                           END IF                                                                      R = (A.sub.n-1 /A.sub.n)(R.sup.2 - X.sub.n.sup.2).sup.1/2                   Modification of the decoding.                                                   R = A.sub.N                                                                   FOR n = N DOWN TO 1                                                             X.sub.n = -2 INT((R - 1)/2) - 1                                             y = INT (((A.sub.n-1 /A.sub.n)(R.sup.2 - X.sub.n.sup.2).sup.1/2  - 1)/2       Y = 2 y + 1                                                                   WHILE Code >=V.sub.n-1 (Y)                                                        Code = Code - V.sub.n-1 (Y)                                               X.sub.n = X.sub.n + 2                                                         y = 2 INT(((A.sub.n-1 /A.sub.n)(R.sup.2 - X.sub.n.sup.2).sup.1/2 -1)/2             Y = 2 y + 1                                                            END WHILE                                                                       R = Y                                                                       END FOR                                                                         Appendix 5                                                                    Initialisation: computation of the volumes and numerators                       Den.sub.N-1 = D.sup.2                                                       FOR i=N-2 DOWN TO 0 DO Den.sub.i+1 =Den.sub.i+1.A.sub.i+1.sup.2                 Precomputed                                                               denominators                                                                    Computation of the volumes (dimensions 2 . . . N-1 only)                    (Z) FOR 1 = 1 TO N-2 DO NV.sub.i-1 = 0                                          (D) FOR 1 = 1 TO N-2 DO NV.sub.o,i-1 = 0                                    Mult.sub.n-1 = D                                                                FOR 1 = N-2 DOWN TO 0 DO Mult.sub.i =Mult.sub.i+1 A.sub.i+1                   XMax.sub.N-1 =A.sub.N-1 /D integer division                                   maxCode = -1                                                                  Num.sub.N-1 = 1                                                               n = N                                                                       (D) Sum.sub.n =0                                                                      Sum of the previous coordinates                                       New Dimension                                                                       n = n - 1                                                               Xmax.sub.n-1 = 0                                                                X.sub.n = -XMax.sub.n - 1                                                     InitialNum.sub.n = Num.sub.n A.sub.n.sup.2                                    previous V.sub.n = maxCode call to the last final value                     Increase coordinate                                                               X.sub.n = X.sub.n + 1                                                     (D) Sum.sub.n = Sum.sub.n+1 + X.sub.n                                         (D) p = REM2(Sum.sub.n)                                                                   current parity                                                    Num.sub.n-1 = initialNum.sub.n - Mult.sub.n.sup.2 X.sub.n.sup.2                 ANum.sub.n-1 = Num.sub.n-1 A.sub.n-1.sup.2                                    IF X.sub.n <= 0                                                                   WHILE Den.sub.n-1 XMax.sub.n-1.sup.2 < Anum.sub.n-1 DO                  WHILE Den.sub.n-1 XMax.sub.n-1.sup.2 >ANum.sub.n-1 DO XMax.sub.n-1 =          XMax.sub.n-1.sup.-1                                                             IF n > GOTO nextDimension                                                   (Z) maxCode = maxCode+(1+2 XMax.sub.o)                                          (D) IF p = Parity THEN maxCode = max Code +1+2 INT(XMax.sub.o /2)           (D)   ELSE maxCode = maxCode + 2 INT((XMax.sub.o +1)/2)                       Test of coordinate                                                                IF X.sub.n <XMax.sub.n GOTO increaseCoordinate                              IF n = N-1 THEN END                                                           vol = maxCode - previousV.sub.n                                             Keep the max values of Num in ascending order, with their associated           value V                                                                      (D) IF Sum.sub.n+1 =2INT(Sum.sub.n+1 /2)THEN p=0 ELSE p=1 current parity      (Z/D)                                                                             IF NV.sub.n-1  = 0 first volume of this dimension.                        (Z/D) NV.sub.n-1 =1                                                             (Z/D) maxNumer.sub.n-1,1 = Num.sub.n                                          (Z/D) V.sub.n-1 = vol                                                       ELSE     this is not the first volume: test the order                         (Z/D) M = NV.sub.n-1                                                             FOR i = NV.sub.n-1 - 1 DOWN TO 0                                           (Z/D)   IF vol = V.sub.n-1,i                                                  (Z/D)     IF Num.sub.n >maxNumer.sub.n-1,i                                    (Z/D)       maxNumer.sub.n-1,1 = Num.sub.n                                            GOTO numerFound                                                         END IF                                                                      (Z/D)   If vol<V.sub.n-1,i THEN M = i                                         END FOR                                                                         END FOR                                                                     (Z/D)                                                                             IF M <= Nv.sub.n-1 modify maxNumer and V                                  (Z/D)   FOR - = NV.sub.n-1 DOWN TO M+1                                        (Z/D)     maxNumer.sub.n-1,i = maxNumer.sub.n-1,i-1                             (Z/D) V.sub.n-1,i = V.sub.n-1,i-1                                           END FOR                                                                           END IF                                                                    (Z/D)                                                                             maxNumer.sub.n-1,M = Num.sub.n                                              (Z/D) V.sub.n-1,M = vol                                                       (Z/D) NV.sub.n-1 = NV.sub.n-1 + 1                                           END IF                                                                        number found                                                                      n = n + 1                                                                   GOTO testCoordinate                                                         B. Coding algorithm (the x.sub.i are assumed to be correct).                      Code = 0                                                                    R = A.sub.N-1                                                                 Num = 1                                                                       Mult = D                                                                    (D) Sum.sub.n = 0 sum of the previous coordinates                             FOR n = N - 1 DOWN TO 1 Loop over the dimensions                                     R.sub.O = 0                                                              initialNum = Num A.sub.N.sup.2                                              If the p.sup.th coordinate is greater than the minimum R, add volumes          corresponding to -R, -R+1, . . . X.sub.n -1 to the code                            IF X.sub.n > -R                                                                 FOR iX = -R TO X.sub.n-1                                                        Num = initialNum - Mult.sup.2 iX.sup.2                              (D)       Sum.sub.n = Sum.sub.n-1 +iX                                            p = REM2(Sum.sub.n) current parity                                                    IF n>1 Si n>1, the volumes can be accessed                         through the     value of Num                                                              i = 1                                                             (Z/D)       WHILE Num>maxNumer.sub.n-1,i DO i = i + 1                           (Z/D) Code = Code + V.sub.n-1,i                                                       ELSE If n=1, the volumes are computed                                          ANum = Num A.sub.o 2                                                 IF iX <= 0                                                                                WHILE Den.sub.o R.sub.o .sup.2 <ANum DO R.sub.o =R.sub.o +1                WHILE Den.sub.o R.sub.o.sup.2 >ANum DO R.sub.o =R.sub.o -1         (Z)           Code = Code + 1 + 2*R.sub.o                                       (D) IF p = parity THEN Code=Code+1+2INT(R.sub.o /2)                         (D)               ELSE Code=Code+2INT((R.sub.o +1)/2)                                     END IF                                                                    END FOR                                                               END IF                                                                        (D)   Sum.sub.n = Sum.sub.n+1 + X.sub.n                                       If necessary, compute R for the next dimension                                    Num = initialNum - Mult.sup.2 X.sub.n.sup.2                                 Anum = Num A.sub.n-1 2                                                      IF n>1      if n>1, iterative computation                                     R = 0                                                                           WHILE Den.sub.n-1 R.sup.2 <ANum DO R = R+1                                    IF Den.sub.n-1 R.sup.2 >ANum THEN R=R -1                                      Mult = Mult A.sub.n                                                             ELSE                                                                             if n = 1 the next dimension is 1                                       Adjust R taking into account the fact that it can only increase if            X.sub.1 ≦0 and                                                           decrease if X.sub.1 <0                                                            R = R.sub.o                                                               IF X.sub.1 <= 0                                                                         WHILE Den.sub.o R.sup.2 < ANum DO R = R + 1                       WHILE Den.sub.o R.sup.2 >ANum DO R = R-1                                      (Z) Code = Code + X.sub.o + R Final adjustment of the code                      (D) IF X.sub.o > -R                                                         (D)         FOR i = -R TO X.sub.o -1                                          (D)           IF REM2 (Sum.sub.1 +i) = Parity                                 (D) END IF                                                                      (D) END FOR                                                                 C. Decoding algorithm                                                             R = A.sub.N-1 /D integer division                                           Num = 1                                                                       Mult = D                                                                    (D) Sum.sub.n of the previous coordinates                                         FOR n = N - 1 DOWN TO 1 Loop over the dimensions                          If the n.sup.th coordinate X[n] is greater than its minimum, R, the code      contains                                                                        the sum of the n-dimensional volumes corresponding to -R, -R+1, . . .       X.sub.n -1                                                                          R.sub.o = 0                                                               initialNum Num A.sub.n.sup.2                                                  X.sub.n = -R                                                                  Num = initialNum - Mult.sup.2 X.sub.n.sup.2                                 (D)   p = REM2(Sum.sub.n+1 + X.sub.n)                                         Trial subtraction of volumes to form the code                                       IF n>1 These volumes are tabulated for n>1, as being a                    ,9 function of Num                                                                    i = 1                                                               (Z/D) WHILE Num>maxNumer.sub.n,i DO i = i + 1                                   (Z/D) WHILE Code>=V.sub.n,i                                                 (Z/D)   Code = Code - V.sub.n,i                                                  X.sub.n = X.sub.n + 1                                                        (D) P = 1 - P                                                                  Num = initial Num - Mult.sup.2 X.sub.n.sup.2                                  i = 1                                                                        (Z/D) WHILE Num > maxNumer.sub.n,i DO i = i + 1                             END WHILE                                                                         ELSE    If n = 1, the volumes are almost easy to                          compute . . .                                                                       ANum = Num A.sub.o.sup.2                                                  IF X.sub.n <=0                                                                      WHILE Den.sub.o R.sub.o.sup.2 <ANum DO R.sub.o = R.sub.o + 1          WHILE Den.sub.o R.sub.o.sup.2 >ANum DO R.sub.o = R.sub.o - 1                  (Z)   length = 1 + 2 R.sub.o                                                    (D) IF p = Parity THEN length = 1 + 2 INT(R.sub.o /2)                       (D)       ELSE length = 2 INT((R.sub.o + 1)/2)                                WHILE Code>= length                                                                   Code = Code - length                                                    X.sub.n = X.sub.n + 1                                                       (D)     p = 1 - p change the parity                                                   Num = initialNum - Mult.sup.2 X.sub.n.sup.2                             ANum = Num A.sub.o.sup.2                                                      IF X.sub.n <= 0                                                                         WHILE Den.sub.o R.sub.o.sup.2<ANum DO R.sub.o = R.sub.o + 1               WHILE Den.sub.o R.sub.o.sup.2 >ANum DO R.sub.o = R.sub.o - 1          (Z)   length = 1 + 2 R.sub.o                                                  (D)  IF p = Parity THEN length = 1 + 2 INT(R.sub.o /2)                        ELSE length = 2 INT((R.sub.o +1/2)                                              END WHILE                                                                     END IF                                                                      If necessary, compute R for the next dimension.                                   ANum = Num A.sub.n-1.sup.2                                                (D) Sum.sub.n = Sum.sub.n+1 + X.sub.n                                         IF n>1 if n>1, iterative computation                                               R = 0                                                                      WHILE Den.sub.n-1 R.sup.2 <ANum DO R = R+1                                    IF Den.sub.n-1 R.sup.2 >ANum THEN R = R - 1                                   Mult = Mult A.sub.n.sup.2                                                   ELSE If n-1, the next dimension is 1                                          Adjust R taking into account the fact that it can only increase if X1< =      0,                                                                              and decrease if X.sub.1 >0                                                       R = R.sub.o                                                                IF X.sub.1 <=0                                                                    WHILE Den.sub.o R.sup.2<ANum DO R = R + 1                               WHILE Den.sub.o R.sup.2>ANum DO R = R - 1                                     (Z)  X.sub.o = -R Last coordinate code. . .                                     (D) p = Sum.sub.1 - 2 INT(Sum.sub.1 /2)                                       (D) X.sub.o = -R + 2 Last coordinate code                                     (D) p.sub.o = REM2(X.sub.o) parity of X.sub.o                                 (D) IF Parity = 0                                                           (D)   IF p.sub.o <>p THEN X.sub.o =X.sub.o +1                                 (D)  ELSE                                                                           IF p.sub.o =p THEN X.sub.o =X.sub.o +1                                  (D)  END IF                                                                   END IF                                                                          END FOR                                                                     NB: The instructions labelled (Z) are those to be used when the axes           have integer lengths. The instructions labelled (D) relate to grids of       points                                                                          having coordinates with even and odd sums. For the instructions             labelled                                                                        (Z/D), NV.sub.a,b is replaced by NV.sub.p,a,b, V.sub.a,b by V.sub.p,a,b     and maxNumer.sub.a,b                                                           is replaced by maxNumer.sub.p,a,b if the current grid is D.sub.n0 or         D.sub.n-1. For D.sub.n,                                                         the variable parity is 0 for D.sub.n0 and 1 for D.sub.n1. The function      REM2(X)                                                                         computes the remainder when X is divided by 2: it is equivalent to X -        INT(X/2).                                                                     Appendix 6                                                                    First dimension                                                               FOR A = 0 TO A.sub.1 STEP 2 DO V.sub.0,1 (A)=A+1                              FOR A = 1 TO A.sub.1 STEP 2 DO V.sub.1,1 (A)=A+1                              Dimensions 2 . . . N-1:                                                       FOR n = 2 TO N-1                                                                FOR A = 0 TO A.sub.n                                                            V.sub.0,n (A)=0                                                           V.sub.1,n (A)=0                                                               FOR X.sub.n =0 TO A                                                                 X.sub.n-1 =(A.sub.n-1 /A.sub.n) (A.sup.2 -X.sub.n.sup.2)1/2                    IF X.sub.n = 2 INT(X.sub.n /2)                                                 IF X.sub.n = 0                                                                  V.sub.0,n (A) = V.sub.0,n-1 (X.sub.n-1)                             V.sub.1,n (A) = V.sub.1,n-1 (X.sub.n-1)                                               ELSE                                                                            V.sub.0,n (A) = V.sub.0,n (A) + 2*V.sub.0,n-1)(X.sub.n-1)                      V.sub.1,n (A) = V.sub.1,n (A) + 2*V.sub.1,n-1)(X.sub.n-1)                  END IF                                                                      ELSE                                                                              V.sub.0,n (A) = V.sub.0,n (A) + 2*V.sub.1,n-1)(X.sub.n-1)                      V.sub.1,n (A) = V.sub.1,n (A) + 2*V.sub.0,n-1)(X.sub.n-1)                ENDIF                                                                 END FOR                                                                           END FOR                                                                   END FOR                                                                       __________________________________________________________________________

I claim:
 1. A process for the vector quantization of low bit ratevocoders, comprising:determining a coding region by surrounding with anenvelope a scatter of points of an autocorrelation matrix of reflectioncoefficients of a filter configured to model a vocal tract, wherein theenvelope has a shape selected from the group consisting of ahyperellipsoid shape and a pyramidal shape, the envelope being centeredat the barycentre of the scatter of points; determining principal axesof the volume of points inside the envelope; projecting areacoefficients of the autocorrelation matrix onto the principal axes;partitioning the interior volume of the envelope into elementaryvolumes; and coding partition coefficients resulting from partitioningthe interior volume on the basis of coordinates of said partitioncoefficients in a space defined by the principal axes of the volume ofthe points inside the envelope, while allocating as code values onlyvalues corresponding to locations of the elementary volumes in whichsaid partition coefficients lie.
 2. The process according to claim 1,wherein partitioning the interior volume of the envelope comprisespartitioning said volume into slices perpendicular to a first principalaxis direction from a first end slice to a slice preceding a last slicecontaining a point to be coded, and further comprising:accumulating thenumbers of points contained in each successive slice; and adding to thenumber of points obtained the number of points remaining in the lastslice so as to arrive at the point to be coded.
 3. The process accordingto claim 2, further comprising converting actual values of thecoordinates of the points to be coded into a nearest integer value. 4.The process according to claim 2, wherein coding the partitioncoefficients comprises considering only half-integer coordinates.
 5. Theprocess according to claim 2, wherein coding the partition coefficientscomprises considering only coordinates with one of even and odd sums. 6.The process according to claim 2, wherein the envelope surrounding thescatter of points has a hyperellipsoid shape.
 7. The process accordingto claim 2, wherein the envelope surrounding the scatter of points has apyramidal shape.
 8. The process according to claim 2, further comprisingadjusting the interior volume of the envelope by fractional coordinateaxis lengths.
 9. The process according to claim 1, wherein the envelopesurrounding the scatter of points has a hyperellipsoid shape.
 10. Theprocess according to claim 9, further comprising converting actualvalues of the coordinates of the points to be coded into a nearestinteger value.
 11. The process according to claim 9, wherein coding thepartition coefficients comprises considering only half-integercoordinates.
 12. The process according to claim 9, wherein coding thepartition coefficients comprises considering only coordinates with oneof even and odd sums.
 13. The process according to claim 9, furthercomprising adjusting the interior volume of the envelope by fractionalcoordinate axis lengths.
 14. The process according to claim 1, whereinthe envelope surrounding the scatter of points has a pyramidal shape.15. The process according to claim 14, further comprising convertingactual values of the coordinates of the points to be coded into anearest integer value.
 16. The process according to claim 14, whereincoding the partition coefficients comprises considering onlyhalf-integer coordinates.
 17. The process according to claim 14, whereincoding the partition coefficients comprises considering only coordinateswith one of even and odd sums.
 18. The process according to claim 14,further comprising adjusting the interior volume of the envelope byfractional coordinate axis lengths.
 19. The process according to claim1, further comprising adjusting the interior volume of the envelope byfractional coordinate axis lengths.
 20. The process according to claim19, wherein the fractional axis lengths have a common denominator.